home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d12 / v10n04.arc / GRAYS.C < prev    next >
C/C++ Source or Header  |  1991-02-01  |  7KB  |  222 lines
  1. /*----------------------------------------------------------
  2.    GRAYS.C -- Gray Shades Using Windows 3.0 Palette Manager
  3.               (c) Charles Petzold, 1990
  4.   ----------------------------------------------------------*/
  5.  
  6. #include <windows.h>
  7. #include "grays.h"
  8.  
  9. long FAR PASCAL WndProc (HWND, WORD, WORD, LONG) ;
  10.  
  11. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  12.                     LPSTR lpszCmdLine, int nCmdShow)
  13.      {
  14.      char     szAppName [] = "Grays" ;
  15.      HWND     hwnd ;
  16.      MSG      msg ;
  17.      WNDCLASS wndclass ;
  18.  
  19.      if (!hPrevInstance) 
  20.           {
  21.           wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
  22.           wndclass.lpfnWndProc   = WndProc ;
  23.           wndclass.cbClsExtra    = 0 ;
  24.           wndclass.cbWndExtra    = 0 ;
  25.           wndclass.hInstance     = hInstance ;
  26.           wndclass.hIcon         = NULL ;
  27.           wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  28.           wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
  29.           wndclass.lpszMenuName  = szAppName ;
  30.           wndclass.lpszClassName = szAppName ;
  31.  
  32.           RegisterClass (&wndclass) ;
  33.           }
  34.  
  35.      hwnd = CreateWindow (szAppName, "Gray Shades",
  36.                           WS_OVERLAPPEDWINDOW,
  37.                           CW_USEDEFAULT, CW_USEDEFAULT,
  38.                           CW_USEDEFAULT, CW_USEDEFAULT,
  39.                           NULL, NULL, hInstance, NULL) ;
  40.  
  41.      ShowWindow (hwnd, nCmdShow) ;
  42.      UpdateWindow (hwnd) ;
  43.  
  44.      while (GetMessage (&msg, NULL, 0, 0))
  45.           {
  46.           TranslateMessage (&msg) ;
  47.           DispatchMessage (&msg) ;
  48.           }
  49.      return msg.wParam ;
  50.      }
  51.  
  52. long FAR PASCAL WndProc (HWND hwnd, WORD message, WORD wParam, LONG lParam)
  53.      {
  54.      static HPALETTE hPal ;
  55.      static short    cxClient, cyClient ;
  56.      static WORD     wDisplay = IDM_DITHERED ;
  57.      HBRUSH          hBrush ;
  58.      HDC             hdc ;
  59.      HMENU           hMenu ;
  60.      LOCALHANDLE     hLocalMem ;
  61.      LOGPALETTE      *plp ;
  62.      long            i ;
  63.      PAINTSTRUCT     ps ;
  64.      RECT            rc ;
  65.      WORD            nGrayLevel ;
  66.  
  67.      switch (message)
  68.           {
  69.           case WM_CREATE:
  70.  
  71.                     // Allocate memory for LOGPALETTE structure and lock it
  72.  
  73.                hLocalMem = LocalAlloc (LMEM_MOVEABLE, sizeof (LOGPALETTE) +
  74.                                                  64 * sizeof (PALETTEENTRY)) ;
  75.  
  76.                plp = (LOGPALETTE *) LocalLock (hLocalMem) ;
  77.  
  78.                     // Initialize the fields of the LOGPALETTE structure
  79.  
  80.                plp->palVersion    = 0x300 ;
  81.                plp->palNumEntries = 65 ;
  82.  
  83.                for (i = 0 ; i <= 64 ; i++)
  84.                     {
  85.                     nGrayLevel = min (255, 4 * i) ;
  86.  
  87.                     plp->palPalEntry[i].peRed   = nGrayLevel ;
  88.                     plp->palPalEntry[i].peGreen = nGrayLevel ;
  89.                     plp->palPalEntry[i].peBlue  = nGrayLevel ;
  90.                     plp->palPalEntry[i].peFlags = 0 ;
  91.                     }
  92.  
  93.                     // Create the logical palette
  94.  
  95.                hPal = CreatePalette (plp) ;
  96.  
  97.                     // Unlock and free the allocated memory
  98.  
  99.                LocalUnlock (hLocalMem) ;
  100.                LocalFree (hLocalMem) ;
  101.                return 0 ;
  102.  
  103.           case WM_COMMAND:
  104.                hMenu = GetMenu (hwnd) ;
  105.                                              // Process menu commands
  106.                switch (wParam)
  107.                     {
  108.                     case IDM_DITHERED:
  109.                     case IDM_PALETTERGB:
  110.                     case IDM_PALETTEINDEX:
  111.                          CheckMenuItem (hMenu, wDisplay, MF_UNCHECKED) ;
  112.                          wDisplay = wParam ;
  113.                          CheckMenuItem (hMenu, wDisplay, MF_CHECKED) ;
  114.  
  115.                          InvalidateRect (hwnd, NULL, TRUE) ;
  116.                          return 0 ;
  117.                     }
  118.                break ;
  119.  
  120.           case WM_SIZE:
  121.                cxClient = LOWORD (lParam) ;
  122.                cyClient = HIWORD (lParam) ;
  123.                return 0 ;
  124.  
  125.           case WM_PAINT:
  126.                hdc = BeginPaint (hwnd, &ps) ;
  127.  
  128.                          // If the display is not to be dithered, select and
  129.                          //      realize the palette
  130.  
  131.                if (wDisplay != IDM_DITHERED)
  132.                     {
  133.                     SelectPalette (hdc, hPal, FALSE) ;
  134.                     RealizePalette (hdc) ;
  135.                     }
  136.  
  137.                for (i = 0 ; i <= 64 ; i++)
  138.                     {
  139.                          // Use a RECT structure for each of 65 rectangles
  140.  
  141.                     rc.left   = (short) ( i      * cxClient / 65) ;
  142.                     rc.top    = 0 ;
  143.                     rc.right  = (short) ((i + 1) * cxClient / 65) ;
  144.                     rc.bottom = cyClient ;
  145.  
  146.                          // Determine the level of gray
  147.  
  148.                     nGrayLevel = min (255, 4 * i) ;
  149.  
  150.                          // Create a brush depending on the display
  151.  
  152.                     switch (wDisplay)
  153.                          {
  154.                          case IDM_DITHERED:
  155.                               hBrush = CreateSolidBrush (RGB (
  156.                                         nGrayLevel, nGrayLevel, nGrayLevel)) ;
  157.                               break ;
  158.  
  159.                          case IDM_PALETTERGB:
  160.                               hBrush = CreateSolidBrush (PALETTERGB (
  161.                                         nGrayLevel, nGrayLevel, nGrayLevel)) ;
  162.                               break ;
  163.  
  164.                          case IDM_PALETTEINDEX:
  165.                               hBrush = CreateSolidBrush (PALETTEINDEX (i)) ;
  166.                               break ;
  167.                          }
  168.  
  169.                          // Fill the rectangle and delete the brush
  170.  
  171.                     FillRect (hdc, &rc, hBrush) ;
  172.                     DeleteObject (hBrush) ;
  173.                     }
  174.  
  175.                EndPaint (hwnd, &ps) ;
  176.                return 0 ;
  177.  
  178.           case WM_QUERYNEWPALETTE:
  179.                hdc = GetDC (hwnd) ;
  180.  
  181.                SelectPalette (hdc, hPal, FALSE) ;
  182.  
  183.                if (RealizePalette (hdc) > 0)
  184.                     {
  185.                     ReleaseDC (hwnd, hdc) ;
  186.                     InvalidateRect (hwnd, NULL, FALSE) ;
  187.                     return TRUE ;
  188.                     }
  189.                else
  190.                     {
  191.                     ReleaseDC (hwnd, hdc) ;
  192.                     return FALSE ;
  193.                     }
  194.                break ;
  195.  
  196.           case WM_PALETTECHANGED:
  197.                if (wParam != hwnd)
  198.                     {
  199.                     hdc = GetDC (hwnd) ;
  200.  
  201.                     SelectPalette (hdc, hPal, FALSE) ;
  202.  
  203.                     if (RealizePalette (hdc) > 0)
  204.                          {
  205.                          InvalidateRect (hwnd, NULL, FALSE) ;
  206.                          }
  207.  
  208.                     ReleaseDC (hwnd, hdc) ;
  209.                     }
  210.                return 0 ;
  211.  
  212.           case WM_DESTROY :
  213.  
  214.                     // Delete the logical palette
  215.  
  216.                DeleteObject (hPal) ;
  217.                PostQuitMessage (0) ;
  218.                return 0 ;
  219.           }
  220.      return DefWindowProc (hwnd, message, wParam, lParam) ;
  221.      }
  222.